package com.chongchong.online.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.chongchong.online.wrapper.OnlineRuleWrapper;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
import com.chongchong.common.constant.ErrorCodeEnum;
import com.chongchong.common.tool.CommonUtil;
import com.chongchong.common.validator.UpdateGroup;
import com.chongchong.core.mp.object.MyModelUtil;
import com.chongchong.core.mp.object.MyOrderParam;
import com.chongchong.core.mp.object.MyRelationParam;
import com.chongchong.core.mp.support.Condition;
import com.chongchong.core.mp.support.Query;
import com.chongchong.core.tool.api.R;
import com.chongchong.online.dto.OnlineRuleDto;
import com.chongchong.online.entity.OnlineRule;
import com.chongchong.online.service.IOnlineRuleService;
import com.chongchong.online.vo.OnlineRuleVo;
import io.swagger.annotations.Api;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import javax.validation.groups.Default;
import java.util.List;

/**
 * 验证规则操作控制器类。
 *
 * @author Jerry
 * @date 2021-06-06
 */
@Api(tags = "验证规则操作接口")
@Slf4j
@RestController
@AllArgsConstructor
@RequestMapping("/onlinerule")
public class OnlineRuleController {

    private IOnlineRuleService onlineRuleService;

    /**
     * 新增验证规则数据。
     *
     * @param onlineRuleDto 新增对象。
     * @return 应答结果对象，包含新增对象主键Id。
     */
    @ApiOperationSupport(ignoreParameters = {"onlineRuleDto.ruleId"})
    @PostMapping("/add")
    public R<Long> add(@RequestBody OnlineRuleDto onlineRuleDto) {
        String errorMessage = CommonUtil.getModelValidationError(onlineRuleDto);
        if (errorMessage != null) {
            return R.fail(errorMessage);
        }
        OnlineRule onlineRule = MyModelUtil.copyTo(onlineRuleDto, OnlineRule.class);
        onlineRule = onlineRuleService.saveNew(onlineRule);
        return R.data(onlineRule.getRuleId());
    }

    /**
     * 更新验证规则数据。
     *
     * @param onlineRuleDto 更新对象。
     * @return 应答结果对象。
     */
    @PostMapping("/update")
    public R<Void> update(@RequestBody OnlineRuleDto onlineRuleDto) {
        String errorMessage = CommonUtil.getModelValidationError(onlineRuleDto, Default.class, UpdateGroup.class);
        if (errorMessage != null) {
			return R.fail(errorMessage);
        }
        OnlineRule onlineRule = MyModelUtil.copyTo(onlineRuleDto, OnlineRule.class);
        OnlineRule originalOnlineRule = onlineRuleService.getById(onlineRule.getRuleId());
        if (originalOnlineRule == null) {
            // NOTE: 修改下面方括号中的话述
            errorMessage = "数据验证失败，当前在线字段规则并不存在，请刷新后重试！";
			return R.fail(errorMessage);
        }
        if (!onlineRuleService.update(onlineRule, originalOnlineRule)) {
            return R.fail(ErrorCodeEnum.DATA_NOT_EXIST.getErrorMessage());
        }
        return R.data(null);
    }

    /**
     * 删除验证规则数据。
     *
     * @param ruleId 删除对象主键Id。
     * @return 应答结果对象。
     */
    @PostMapping("/delete")
    public R<Void> delete(@RequestBody Long ruleId) {
        String errorMessage;
        if (CommonUtil.existBlankArgument(ruleId)) {
            return R.fail(ErrorCodeEnum.ARGUMENT_NULL_EXIST.getErrorMessage());
        }
        // 验证关联Id的数据合法性
        OnlineRule originalOnlineRule = onlineRuleService.getById(ruleId);
        if (originalOnlineRule == null) {
            // NOTE: 修改下面方括号中的话述
            errorMessage = "数据验证失败，当前在线字段规则并不存在，请刷新后重试！";
			return R.fail(errorMessage);
        }
        if (!onlineRuleService.remove(ruleId)) {
            errorMessage = "数据操作失败，删除的对象不存在，请刷新后重试！";
			return R.fail(errorMessage);
        }
        return R.data(null);
    }

    /**
     * 列出符合过滤条件的验证规则列表。
     *
     * @param onlineRuleDtoFilter 过滤对象。
     * @param orderParam          排序参数。
     * @param query           分页参数。
     * @return 应答结果对象，包含查询结果集。
     */
    @GetMapping("/list")
	public R<IPage<OnlineRuleVo>> list(OnlineRuleDto onlineRuleDtoFilter,
									   MyOrderParam orderParam, Query query) {
		OnlineRule onlineRuleFilter = MyModelUtil.copyTo(onlineRuleDtoFilter, OnlineRule.class);
		String orderBy = MyOrderParam.buildOrderBy(orderParam, OnlineRule.class);
		List<OnlineRule> onlineRuleList = onlineRuleService.getOnlineRuleListWithRelation(onlineRuleFilter, orderBy);

//		IPage<OnlineTable> pages = onlineTableService.page(Condition.getPage(query), Condition.getQueryWrapper(flowWorkOrder));

		IPage<OnlineRule> pages = new Page<>(query.getCurrent(), query.getSize());
		pages.setRecords(onlineRuleList);

		return R.data(OnlineRuleWrapper.build().pageVO(pages));
	}

	/**
	 * 列出符合过滤条件的验证规则列表。
	 *
	 * @param onlineRule 过滤对象。
	 * @return 应答结果对象，包含查询结果集。
	 */
	@GetMapping("/listNoPage")
	public R<List<OnlineRuleVo>> listNoPage( OnlineRule onlineRule) {
		List<OnlineRule> onlineRuleList = onlineRuleService.list(Condition.getQueryWrapper(onlineRule));

		return R.data(OnlineRuleWrapper.build().listVO(onlineRuleList));
	}

    /**
     * 查看指定验证规则对象详情。
     *
     * @param ruleId 指定对象主键Id。
     * @return 应答结果对象，包含对象详情。
     */
    @GetMapping("/view")
    public R<OnlineRuleVo> view(@RequestParam Long ruleId) {
        if (CommonUtil.existBlankArgument(ruleId)) {
            return R.fail(ErrorCodeEnum.ARGUMENT_NULL_EXIST.getErrorMessage());
        }
        OnlineRule onlineRule = onlineRuleService.getByIdWithRelation(ruleId, MyRelationParam.full());
        if (onlineRule == null) {
            return R.fail(ErrorCodeEnum.DATA_NOT_EXIST.getErrorMessage());
        }
        return R.data(OnlineRuleWrapper.build().entityVO(onlineRule));
    }
}
